home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1998 August: Tool Chest / Dev.CD Aug 98 TC.toast / What's New? / Software Development Kits / Translation Manager / Sample Code / Translation Extension Example / LowerToUpperCase.c < prev    next >
Encoding:
C/C++ Source or Header  |  1998-06-05  |  18.4 KB  |  592 lines  |  [TEXT/CWIE]
  1. /*
  2.     File:        LowerToUpperCase.c 
  3.  
  4.     Contains:    Source to a Translation Extension which converts from lower to upper case
  5.     
  6.     Copyright:    © 1994,1998 by Apple Computer, Inc., all rights reserved.
  7. */
  8.  
  9. #include <Types.h>
  10. #include <Files.h>
  11. #include <MixedMode.h>
  12. #include <Traps.h>
  13. #include <Errors.h>
  14. #include <Memory.h>
  15. #include <Resources.h>
  16. #include <Components.h>
  17. #include <TranslationExtensions.h>
  18.  
  19. #include "TranslationComponent.h"
  20. #include "LowerToUpperCase.h"
  21.  
  22. #include "string.h"
  23.  
  24. //___________________________________________________________________________________________________________
  25. //
  26. // Structures
  27. //
  28.  
  29. // Our magic cookie to tell if our translation list is initialized or not
  30. #define kModificationDateMagicCookie    0x00000001
  31.  
  32. // Set up a fixed scrap translation list structure for easy access
  33. #if defined(powerc) || defined (__powerc)
  34. #pragma options align=mac68k
  35. #endif
  36. struct OurScrapTranslationList
  37. {
  38.     unsigned long    modDate;
  39.     unsigned long    groupCount;
  40.     unsigned long    sourceCount;
  41.     unsigned long    sourceEntrySize;
  42.     ScrapTypeSpec    sourceType;
  43.     unsigned long    destinationCount;
  44.     unsigned long    destinationEntrySize;
  45.     ScrapTypeSpec    desinationType;
  46. };
  47. #if defined(powerc) || defined(__powerc)
  48. #pragma options align=reset
  49. #endif
  50.  
  51. typedef struct OurScrapTranslationList OurScrapTranslationList;
  52. typedef OurScrapTranslationList *OurScrapTranslationListPtr, **OurScrapTranslationListHandle;
  53.  
  54.  
  55. // Set up a fixed file translation list structure for easy access
  56. #if defined(powerc) || defined (__powerc)
  57. #pragma options align=mac68k
  58. #endif
  59. struct OurFileTranslationList
  60. {
  61.     unsigned long    modDate;
  62.     unsigned long    groupCount;
  63.     unsigned long    sourceCount;
  64.     unsigned long    sourceEntrySize;
  65.     FileTypeSpec    sourceType;
  66.     unsigned long    destinationCount;
  67.     unsigned long    destinationEntrySize;
  68.     FileTypeSpec    desinationType;
  69. };
  70. #if defined(powerc) || defined(__powerc)
  71. #pragma options align=reset
  72. #endif
  73.  
  74. typedef struct OurFileTranslationList OurFileTranslationList;
  75. typedef OurFileTranslationList *OurFileTranslationListPtr, **OurFileTranslationListHandle;
  76.  
  77.  
  78. //___________________________________________________________________________________________________________
  79. //
  80. // DoGetScrapTranslationList
  81. //
  82. // This routine is called by the Translation Manager when it needs to find out what formats the scrap
  83. // translator translates between.
  84. //
  85. // Enter:    self    Instance of this translator
  86. //            list    Handle to scrap translation list provided by this translator earlier, or empty handle
  87. //                    if never set before
  88. //
  89. // Exit:    list    Handle to scrap translation list filled in my this routine
  90. //            returns    Any errors that might occur
  91. //
  92. pascal ComponentResult DoGetScrapTranslationList(ComponentInstance             self, 
  93.                                                  ScrapTranslationListHandle    list)
  94. {
  95.     #pragma unused(self)
  96.     
  97.     OurScrapTranslationListHandle    ourList = (OurScrapTranslationListHandle) list;        // Easier to reference
  98.     OSErr                        result = noErr;
  99.  
  100.     // The list never changes here - so see if it's been initialized once by looking
  101.     // for our magic cookie
  102.     if (((*ourList)->modDate) != kModificationDateMagicCookie){
  103.         // Resize the handle to fit our entry
  104.         SetHandleSize((Handle)ourList, sizeof(OurScrapTranslationList));
  105.         if ((result = MemError()) == noErr) {
  106.             // Stuff all the values into our fixed list
  107.             (*ourList)->modDate = kModificationDateMagicCookie;                    // Magic cookie
  108.             (*ourList)->groupCount = 1;                                            // Number groups = 1
  109.             (*ourList)->sourceCount = 1;                                        // Only 1 source type
  110.             (*ourList)->sourceEntrySize = sizeof(ScrapTypeSpec);                // Currently always sizeof(ScrapTypeSpec)
  111.             (*ourList)->sourceType.format = 'TEXT';                                // Source type is always 'TEXT'
  112.             (*ourList)->sourceType.hint = 0;                                    // Don't care about this
  113.             (*ourList)->destinationCount = 1;                                    // Only 1 destination type
  114.             (*ourList)->destinationEntrySize = sizeof(ScrapTypeSpec);            // Currently always sizeof(ScrapTypeSpec)
  115.             (*ourList)->desinationType.format = 'UPPR';                            // Destination type is always 'UPPR'
  116.             (*ourList)->desinationType.hint = 0;                                // Don't care about this
  117.         }        
  118.     }
  119.  
  120.     return result;
  121. }
  122.  
  123. //___________________________________________________________________________________________________________
  124. //
  125. // DoIdentifyScrap
  126. //
  127. // This routine is called to identify a scraps contents.  In this case, just check to see if the scrap
  128. // is type TEXT, and if it is, then we know it's TEXT.
  129. //
  130. // Enter:    self        Instance of this translator
  131. //            dataPtr        Pointer to data to identify
  132. //            dataLength    Size of data referenced by dataPtr
  133. //            dataFormat    Provided format for the data referenced by dataPtr
  134. //
  135. // Exit:    dataFormat    Changed format (if applicable)
  136. //            returns        noErr is scrap contents are TEXT, otherwise noTypeErr
  137. //
  138. pascal ComponentResult DoIdentifyScrap(ComponentInstance    self, 
  139.                                        const void*             dataPtr, 
  140.                                        Size                 dataLength, 
  141.                                        ScrapType*             dataFormat)
  142. {
  143.     #pragma unused(self)
  144.     #pragma unused(dataPtr)
  145.     #pragma unused(dataLength)
  146.  
  147.     OSErr    result = noErr;
  148.     
  149.     // We only know TEXT.  See if the format is that.  If it isn't then we don't translate
  150.     if (*dataFormat != 'TEXT')
  151.         result = noTypeErr;
  152.  
  153.     return result;
  154. }
  155.  
  156. //___________________________________________________________________________________________________________
  157. //
  158. // DoTranslateScrap
  159. //
  160. // This routine is called to perform a scrap translation.  It is only called if the source type is TEXT and
  161. // if DoIdentifyScrap was called as was able to confirm that.  Also, it is only called if the destination type
  162. // is UPPR.
  163. //
  164. // This specific translation converts all lower case characters to upper case.  Leaves the rest alone.
  165. //
  166. // Enter:    self            Instance of this translator
  167. //            progressRefNum    Reference number to progress dialog
  168. //            srcDataPtr        Pointer to source data
  169. //            srcDataLength    Length of data pointed to by srcDataPtr
  170. //            srcType            Type of data pointed to by srcDataPtr (provided via DoIdentifyScrap)
  171. //            srcTypeHint        Hint for data pointed to by srcDataPtr (from ScrapTranslationList)
  172. //            dstData            Handle to place translated destination data into
  173. //            dstType            Type of data to translate srcDataPtr into
  174. //            dstTypeHint        Hint for data to translate to (from ScrapTranslationList)
  175. //
  176. // Exit:    dstData            Handle resized and filled in with translated contents
  177. //            returns            Any errors that might occur.
  178. //            
  179. pascal ComponentResult DoTranslateScrap(ComponentInstance     self, 
  180.                                         TranslationRefNum     progressRefNum,
  181.                                         const void*            srcDataPtr, 
  182.                                         Size                 srcDataLength, 
  183.                                         ScrapType             srcType, 
  184.                                         long                 srcTypeHint,
  185.                                         Handle                 dstData, 
  186.                                         ScrapType             dstType, 
  187.                                         long                 dstTypeHint)
  188. {
  189.     #pragma unused(srcType)
  190.     #pragma unused(srcTypeHint)
  191.     #pragma unused(dstType)
  192.     #pragma unused(dstTypeHint)
  193.  
  194.     OSErr    result;
  195.     char*    currentCharacter;
  196.     char*    lastCharacter;
  197.     char*    writeCharacter;
  198.     short    count;
  199.     Boolean    canceled = false;
  200.     short    myShort;
  201.     Handle  myAdvert;
  202.     OSErr    myErr;
  203.     
  204.     myShort = OpenComponentResFile((Component)self);
  205.     myAdvert = Get1Resource('PICT', kProgressAdvertisement);
  206.     if(myAdvert != nil){
  207.         DetachResource(myAdvert);
  208.         SetTranslationAdvertisement(progressRefNum,(PicHandle) myAdvert);
  209.     }
  210.     else {
  211.         SetTranslationAdvertisement(progressRefNum, nil);
  212.     }
  213.     myErr = CloseComponentResFile(myShort);
  214.     
  215.     // Resize the destination handle to fit all the translated contents
  216.     SetHandleSize(dstData, srcDataLength);
  217.     if ((result = MemError()) == noErr)
  218.     {
  219.         // Give me a pointer to the first character and the last character in the source buffer
  220.         currentCharacter = (char*) srcDataPtr;
  221.         lastCharacter = currentCharacter + srcDataLength;
  222.         
  223.         // Give me a pointer to the first character in the destination buffer
  224.         // (lock it down first because stupid update may move memory)
  225.         HLock(dstData);
  226.         writeCharacter = (char *)*dstData;
  227.         
  228.         // Keep a count for the progress dialog
  229.         count = 0;
  230.         
  231.         // Loop through each of the characters in the buffer
  232.         while ((currentCharacter <= lastCharacter) && !canceled)
  233.         {
  234.             // Are we in the lower case ASCII range?
  235.             if (('a' <= *currentCharacter) && (*currentCharacter <= 'z'))
  236.                 *writeCharacter = (*currentCharacter - ('a' - 'A'));
  237.             else
  238.                 *writeCharacter = *currentCharacter;
  239.             
  240.             // Increment the progress bar
  241.             UpdateTranslationProgress(progressRefNum, ++count * (100.00 / srcDataLength), &canceled);
  242.             
  243.             // Next…
  244.             currentCharacter++;
  245.             writeCharacter++;
  246.         }
  247.             
  248.         // Let it wiggle, see it squiggle
  249.         HUnlock(dstData);
  250.     }
  251.     
  252.     return result;
  253. }
  254.  
  255. //___________________________________________________________________________________________________________
  256. //
  257. // DoGetFileTranslationList
  258. //
  259. // This routine is called by the Translation Manager when it needs to find out what formats the scrap
  260. // translator translates between.
  261. //
  262. // Enter:    self    Instance of this translator
  263. //            list    Handle to file translation list provided by this translator earlier, or empty handle
  264. //                    if never set before
  265. //
  266. // Exit:    list    Handle to file translation list filled in my this routine
  267. //            returns    Any errors that might occur
  268. // 
  269. //
  270. pascal ComponentResult DoGetFileTranslationList(ComponentInstance             self, 
  271.                                                 FileTranslationListHandle    list)
  272. {
  273.     #pragma unused(self)
  274.  
  275.     OurFileTranslationListHandle    ourList = (OurFileTranslationListHandle) list;        // Easier to reference
  276.     OSErr                            result = noErr;
  277.  
  278.     // The list never changes here - so see if it's been initialized once by looking
  279.     // for our magic cookie
  280.     if (((*ourList)->modDate) != kModificationDateMagicCookie)
  281.     {
  282.         // Resize the handle to fit our entry
  283.         SetHandleSize((Handle)ourList, sizeof(OurFileTranslationList));
  284.         if ((result = MemError()) == noErr)
  285.          {
  286.             // Stuff all the values into our fixed list
  287.             (*ourList)->modDate = kModificationDateMagicCookie;                    // Magic cookie
  288.             (*ourList)->groupCount = 1;                                            // Number groups = 1
  289.             (*ourList)->sourceCount = 1;                                        // Only 1 source type
  290.             (*ourList)->sourceEntrySize = sizeof(FileTypeSpec);                    // Currently always sizeof(FileTypeSpec)
  291.             (*ourList)->sourceType.format = 'TEXT';                                // Source type is always 'TEXT'
  292.             (*ourList)->sourceType.hint = 0;                                    // Don't care about this
  293.             (*ourList)->sourceType.flags = 0;
  294.             (*ourList)->sourceType.catInfoType = 'TEXT';
  295.             (*ourList)->sourceType.catInfoCreator = 'ttxt';
  296.             (*ourList)->destinationCount = 1;                                    // Only 1 destination type
  297.             (*ourList)->destinationEntrySize = sizeof(FileTypeSpec);            // Currently always sizeof(FileTypeSpec)
  298.             (*ourList)->desinationType.format = 'UPPR';                            // Destination type is always 'UPPR'
  299.             (*ourList)->desinationType.hint = 0;                                // Don't care about this
  300.             (*ourList)->desinationType.flags = 0;
  301.             (*ourList)->desinationType.catInfoType = 'UPPR';
  302.             (*ourList)->desinationType.catInfoCreator = 'PPd√';                    //??
  303.         }        
  304.     }
  305.  
  306.         
  307.     return result;
  308. }
  309.  
  310. //___________________________________________________________________________________________________________
  311. //
  312. // DoIdentifyFile
  313. //
  314. // This routine is called to identify a file by its contents.  
  315. //
  316. // Enter:    self        Instance of this translator
  317. //            theDoc        file FSSpec
  318. //
  319. // Exit:    docKind        the fileType we decided it was
  320. //            returns        noErr 
  321. //
  322. //
  323. pascal ComponentResult DoIdentifyFile(ComponentInstance self, const FSSpec *theDoc, FileType *docKind)
  324. {
  325.     #pragma unused(self)
  326.     #pragma unused(theDoc)
  327.  
  328.     OSErr myErr = noErr;
  329.     
  330.     //not doing too much here
  331.     
  332.     *docKind = 'TEXT';
  333.     
  334.     return myErr;
  335. }
  336.  
  337. //___________________________________________________________________________________________________________
  338. //
  339. // DoTranslateFile
  340. //
  341. // This routine is called to perform a file translation.  It is only called if the file type is TEXT and
  342. // if DoIdentifyFile was called as was able to confirm that.  Also, it is only called if the destination type
  343. // is UPPR.
  344. //
  345. // This specific translation converts all lower case characters to upper case.  Leaves the rest alone.
  346. //
  347. // Enter:    self            Instance of this translator
  348. //            progressRefNum    Reference number to progress dialog
  349. //            srcDoc            Pointer to source file
  350. //            srcType            fileType provided from the DoIdentifyFile
  351. //            srcTypeHint        Hint for fileType pointed to by srcDoc (from GetTranslationList)
  352. //            dstDoc            Pointer to destination file spec
  353. //            dstType            file Type of destination file
  354. //            dstTypeHint        Hint for fileType to translate to (from GetTranslationList)
  355. //
  356. // Exit:    dstDoc            File is filled in with translation of data in source file
  357. //            returns            Any errors that might occur.
  358. //            
  359. //
  360. pascal ComponentResult DoTranslateFile(ComponentInstance self, TranslationRefNum progressRefNum,
  361.                                             const FSSpec* srcDoc, FileType srcType, long srcTypeHint, 
  362.                                             const FSSpec* dstDoc, FileType dstType, long dstTypeHint)
  363. { 
  364.     #pragma unused(srcType)
  365.     #pragma unused(srcTypeHint)
  366.     #pragma unused(dstType)
  367.     #pragma unused(dstTypeHint)
  368.  
  369.     OSErr     myErr = noErr;
  370.     short    srcRefNum, dstRefNum;
  371.     char    copyBuffer[512];
  372.     long    copyBufferSize;
  373.     Handle    myAdvert;
  374.     short    myShort;
  375.     
  376.     copyBufferSize = 512;
  377.     
  378.     myErr = FSpOpenDF( srcDoc, fsRdPerm, &srcRefNum ); 
  379.     if( myErr == noErr )
  380.     {
  381.         myErr = FSpOpenDF( dstDoc, fsRdWrPerm, &dstRefNum ); 
  382.         if( myErr == noErr )
  383.         {
  384.             myShort = OpenComponentResFile((Component)self);
  385.             myAdvert = Get1Resource('PICT', kProgressAdvertisement);
  386.             if(myAdvert != nil)
  387.             {
  388.                 DetachResource(myAdvert);
  389.                 SetTranslationAdvertisement(progressRefNum,(PicHandle) myAdvert);
  390.             }
  391.             else 
  392.                 SetTranslationAdvertisement(progressRefNum, nil);
  393.             
  394.             myErr = CloseComponentResFile(myShort);
  395.             myErr = CopyFork(*srcDoc, srcRefNum, dstRefNum, ©Buffer, copyBufferSize,progressRefNum );
  396.             
  397.         }
  398.     }
  399.     FSClose(srcRefNum);
  400.     FSClose(dstRefNum);
  401.     
  402.     return myErr;
  403. }
  404.  
  405. //___________________________________________________________________________________________________________
  406. //
  407. // DoGetTranslatedFilename
  408. //
  409. // 
  410. //
  411. pascal ComponentResult DoGetTranslatedFilename(ComponentInstance     self,
  412.                                                FileType                dstType,
  413.                                                long                    dstTypeHint,
  414.                                                FSSpec*                 theDocument)
  415. {
  416.     #pragma unused(self)
  417.     #pragma unused(dstType)
  418.     #pragma unused(dstTypeHint)
  419.     #pragma unused(theDocument)
  420.  
  421.     Str63 theString;
  422.     FSSpec mySpec;
  423.     OSErr  myErr = noErr;
  424.     short  i = 0;
  425.     
  426.     BlockMove( theDocument->name, theString, 64);
  427.     theDocument->name[0] = theDocument->name[0] + 3;
  428.     theDocument->name[1] = 'U';
  429.     theDocument->name[2] = 'U';
  430.     theDocument->name[3] = 'P';
  431.  
  432.     BlockMove( theString + 1, theDocument->name + 4, 60);
  433.     
  434.     myErr = FSMakeFSSpec( theDocument->vRefNum, theDocument->parID, theDocument->name, &mySpec);
  435.     //quick and dirty way of naming, some error checking should be done so no illegal characters are used
  436.     while( myErr != fnfErr ){
  437.         theDocument->name[3] = (char)(theDocument->name[3]) + 1;
  438.         myErr = FSMakeFSSpec( theDocument->vRefNum, theDocument->parID, theDocument->name, &mySpec);
  439.     }
  440.     
  441.     if( myErr == fnfErr ){
  442.         myErr = noErr;
  443.     }
  444.     
  445.     return myErr;
  446.     
  447. }
  448.  
  449.  
  450. pascal    OSErr    CopyFork(FSSpec srcSpec, short srcRefNum,
  451.                          short dstRefNum,
  452.                          void *copyBufferPtr,
  453.                          long copyBufferSize, TranslationRefNum progressRefNum)
  454. {
  455.     ParamBlockRec srcPB;
  456.     ParamBlockRec dstPB;
  457.     OSErr srcError;
  458.     OSErr dstError;
  459.     Boolean canceled = false;
  460.     short    myPercent = 0;
  461.     short    yourPercent;
  462.     unsigned short  numBlocks;
  463.     long    myBlockSize;
  464.     
  465.     char*    currentCharacter;
  466.     char*    lastCharacter;
  467.  
  468.     if ( (copyBufferPtr == NULL) || (copyBufferSize == 0) )
  469.         return ( paramErr );
  470.     
  471.     srcPB.ioParam.ioRefNum = srcRefNum;
  472.     dstPB.ioParam.ioRefNum = dstRefNum;
  473.  
  474.     // preallocate the destination fork and 
  475.     // ensure the destination fork's EOF is correct after the copy 
  476.     srcError = PBGetEOFSync(&srcPB);
  477.     if ( srcError != noErr )
  478.         return ( srcError );
  479.     dstPB.ioParam.ioMisc = srcPB.ioParam.ioMisc;
  480.     dstError = PBSetEOFSync(&dstPB);
  481.     if ( dstError != noErr )
  482.         return ( dstError );
  483.     
  484.     // If copyBufferSize is greater than 512 bytes, make it a multiple of 512 bytes 
  485.     // This will make writes on local volumes faster
  486.     
  487.     myBlockSize = ((copyBufferSize >= 512) && (copyBufferSize % 512)) ?
  488.                                (copyBufferSize / 512) * 512 :
  489.                                (copyBufferSize);
  490.     
  491.     //need to know the size of the file to give user feedback 
  492.     //thru the progress dialog box. So here we count the blocks
  493.     
  494.     srcError = CountTheBlocks(srcSpec.vRefNum,
  495.                                        srcSpec.parID,
  496.                                        srcSpec.name, myBlockSize,
  497.                                        &numBlocks);    
  498.     if( srcError == noErr ){
  499.         myPercent = numBlocks;
  500.     }
  501.     else{
  502.         myPercent = 0;
  503.     }
  504.  
  505.     // reset source fork's mark 
  506.     srcPB.ioParam.ioPosMode = fsFromStart;
  507.     srcPB.ioParam.ioPosOffset = 0;
  508.     srcError = PBSetFPosSync(&srcPB);
  509.     if ( srcError != noErr )
  510.         return ( srcError );
  511.  
  512.     // reset destination fork's mark 
  513.     dstPB.ioParam.ioPosMode = fsFromStart;
  514.     dstPB.ioParam.ioPosOffset = 0;
  515.     dstError = PBSetFPosSync(&srcPB);
  516.     if ( dstError != noErr )
  517.         return ( dstError );
  518.  
  519.     // set up fields that won't change in the loop 
  520.     srcPB.ioParam.ioBuffer = (Ptr)copyBufferPtr;
  521.     srcPB.ioParam.ioPosMode = fsAtMark + 0x0020;// fsAtMark + noCacheBit 
  522.     srcPB.ioParam.ioReqCount = myBlockSize;
  523.  
  524.     dstPB.ioParam.ioBuffer = (Ptr)copyBufferPtr;
  525.     dstPB.ioParam.ioPosMode = fsAtMark + 0x0020;// fsAtMark + noCacheBit 
  526.     yourPercent = 0;
  527.     while ( (srcError == noErr) && (dstError == noErr) )
  528.     {
  529.         srcError = PBReadSync(&srcPB);
  530.         dstPB.ioParam.ioReqCount = srcPB.ioParam.ioActCount;
  531.         
  532.         currentCharacter = (char*)copyBufferPtr;
  533.         lastCharacter = currentCharacter + srcPB.ioParam.ioActCount;
  534.         
  535.         while ((currentCharacter <= lastCharacter) && !canceled)
  536.         {
  537.             // Are we in the lower case ASCII range?
  538.             if (('a' <= *currentCharacter) && (*currentCharacter <= 'z'))
  539.             {
  540.                 *currentCharacter = (*currentCharacter - ('a' - 'A'));
  541.             }
  542.             
  543.             // Next…
  544.             currentCharacter++;
  545.         }
  546.             
  547.         
  548.         dstError = PBWriteSync(&dstPB);
  549.         yourPercent++;
  550.         UpdateTranslationProgress(progressRefNum, ((yourPercent * 100)/myPercent) , &canceled);
  551.         
  552.     }
  553.  
  554.     // make sure there were no errors at the destination 
  555.     if ( dstError != noErr )
  556.         return ( dstError );
  557.  
  558.     // make sure the only error at the source was eofErr 
  559.     if ( srcError != eofErr )
  560.         return ( srcError );
  561.  
  562.     return ( noErr );
  563. }
  564.  
  565.  
  566. static    OSErr    CountTheBlocks(short srcVRefNum,
  567.                                        long srcDirID,
  568.                                        ConstStr255Param srcName, long theBlockSize,
  569.                                        unsigned short *numDataBlks)
  570. {
  571.     HParamBlockRec pb;
  572.     OSErr error;
  573.     unsigned short srcDataBlks;
  574.     
  575.     // get the size of the file's data resource fork 
  576.     pb.fileParam.ioNamePtr = (StringPtr)srcName;
  577.     pb.fileParam.ioVRefNum = srcVRefNum;
  578.     pb.fileParam.ioFVersNum = 0;
  579.     pb.fileParam.ioDirID = srcDirID;
  580.     pb.fileParam.ioFDirIndex = 0;
  581.     error = PBHGetFInfoSync(&pb);
  582.     if ( error == noErr )
  583.     {
  584.     // get number of 512-byte blocks needed for data fork 
  585.     srcDataBlks = ((unsigned long)pb.fileParam.ioFlLgLen % 512) ?
  586.                   (((unsigned long)pb.fileParam.ioFlLgLen >> 9) + 1) :
  587.                   ((unsigned long)pb.fileParam.ioFlLgLen >> 9);
  588.     }
  589.     
  590.     *numDataBlks = ( srcDataBlks *  512 )/ theBlockSize;
  591.     return ( error );
  592. }